const md5 = require('js-md5');
const fs = require('fs');
const path = require('path');
var translateResult = require('./translate.json');
var APP_ID = require('../config').APP_ID;

var SECRET_KEY = require('../config').SECRET_KEY;
var url = require('../config').url;
var toLanguage = require('../config').toLanguage;
const JOIN_CHAR = "%"
var textListNone = []
async function main() {
    try {
        // fileAdd.forEach(async item => {
        //     // 假设你要处理的文件位于当前目录下的src文件夹中  
        const srcDir = path.join(__dirname, 'src');
        const srcMjs = path.join(__dirname, 'mjs');
        const srcResult = path.join(__dirname, 'result');
        //     // 读取src文件夹中的所有文件  
        fs.readdir(srcDir, (err, files) => {
            if (err) throw err;
            function asyncLoop1(times, index = 0, callback) {
                if (index < times) {
                    callback(index).then(async () => {
                        // 异步操作完成后，递归调用自身进行下一次迭代  
                        console.log("访问一次文件")
                        var file = files[index]
                        if (path.extname(file) === '.js') {
                            // 提取文件名（不包括扩展名）  
                            const filename = path.basename(file, '.js');
                            // 构建新的文件名（.mjs扩展名）  
                            const newFile = path.join(srcMjs, `${filename}.mjs`);
                            // 构建原始文件的完整路径  
                            const originalFile = path.join(srcDir, file);

                            // 复制文件  
                            fs.copyFile(originalFile, newFile,async (err) => {
                                if (err) throw err;
                                console.log(`${file} 已成功转换为 ${newFile}`);
                                const module = await import("file://" + newFile);
                                var tranObj = module.default;
                                // 组装文本
                                const textList = flattenObject(tranObj);
                                textList.forEach(async textEle => {
                                    textListNone.push(textEle);
                                })
                            });
                        }
                        asyncLoop1(times, index + 1, callback);
                    }).catch(error => {
                        console.error('Error in async operation:', error);
                    });
                } else {
                    new Promise(resolve => {
                        setTimeout(() => {
                            console.log("文件创建结束===========开始翻译词汇============")
                            console.log("共有 "+textListNone.length+" 个词汇需要翻译，请耐心等待。。。")
                            function asyncLoop(times, index = 0, callback) {

                                if (index < times) {
                                    console.log("还有 "+(textListNone.length-index)+" 个词汇需要翻译，请耐心等待。。。")
                                    callback(index).then(async () => {
                                        var str = textListNone[index];
                                        var result = await getTranslateResult(str)
                                        if (result) {
                                            translateResult[str] = result.trim();
                                            console.log("翻译内容：" + str);
                                            console.log("翻译结果："+ result.trim())
                                            console.log("-------------------------------------------------------------------")
                                        }
                                        asyncLoop(times, index + 1, callback);
                                    }).catch(error => {
                                        console.error('Error in async operation:', error);
                                    });
                                } else {
                                        new Promise(resolve => {
                                            setTimeout(() => {
                                                console.log("单词翻译结束，开始生成翻译文件=====================")
                                                const filePath = path.join(__dirname, 'translate.json');
                                                fs.writeFile(filePath, JSON.stringify(translateResult, null, 2), (err) => {
                                                    if (err) throw err;
                                                    console.log('翻译文件已创建并更新。');
                                                });
                                                console.log(translateResult)
                                                
                                                files.forEach(async fileItem=>{
                                                    // 提取文件名（不包括扩展名）  
                                                    const filename = path.basename(fileItem, '.js');
                                                    // 构建新的文件名（.mjs扩展名）  
                                                    const newFile1 = path.join(srcResult, `${filename}.js`);
                                                    const mjsFile = path.join(srcMjs, `${filename}.mjs`);
                                                    const module1 = await import("file://" + mjsFile);
                                                    var tranObj1 = module1.default;
                                                    
                                                    // for (let key in tranObj1) {  
                                                    //         tranObj1[key] = translateResult[key]; // 修改value  
                                                    // }
                                                    const resultObj = replaceValues(tranObj1,translateResult)
                                                    let objectAsString = 'export default ' + JSON.stringify(resultObj, null, 2);
                                                    fs.writeFileSync(newFile1, objectAsString);
                                                    console.log("已经写入了文件")
                                                })
                                                resolve(); // 异步操作完成  
                                            }, 10000);
                                        })

                                }
                            }
                            function asyncOperation(index) {
                                return new Promise(resolve => {
                                    setTimeout(() => {
                                        resolve(); // 异步操作完成  
                                    }, 10000); // 假设异步操作需要1秒钟  
                                });
                            }
                            asyncLoop(textListNone.length, 0, asyncOperation);
                            resolve(); // 异步操作完成  
                        }, 10000); // 假设异步操作需要1秒钟  
                    })

                }
            }
            function asyncOperation1(index) {
                return new Promise(resolve => {
                    setTimeout(() => { 
                        resolve();
                    }, 10000);
                });
            }
            asyncLoop1(files.length, 0, asyncOperation1);
        });
    } catch (e) {
        console.log(e);
    } finally {
        // console.log("操作完成！！！");
    }
}

async function getTranslateResult(text) {
    // 生成时间戳作为salt  
    const salt = String(Date.now());
    // 构建要签名的字符串  
    const stringToSign = `${APP_ID}${text}${salt}${SECRET_KEY}`;
    // 使用CryptoJS进行MD5加密  
    const sign = md5(stringToSign);

    // 构建请求参数  
    const params = new URLSearchParams({
        q: text,
        from: 'zh',
        to: toLanguage,
        appid: APP_ID,
        salt: salt,
        sign: sign
    });
    var result = null;
    const response = await fetch(url + '?' + params.toString(), {
        method: 'POST',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
        },
        body: params
    })
    result = await response.json();
    if (result.trans_result && result.trans_result.length != 0) {
        return result.trans_result[0].dst
    } else {
        console.log("****************************************************************")
        console.log(result)
        console.log("****************************************************************")
        return null
    }
}

function flattenObject(obj, result = [], prefix = '') {
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            const value = obj[key];
            const newPrefix = prefix ? `${prefix}.${key}` : key;

            if (typeof value === 'object' && value !== null) {
                // 如果值是对象，则递归处理  
                flattenObject(value, result, newPrefix);
            } else {
                // 否则，将值添加到结果数组中  
                result.push(value);
            }
        }
    }
    // 注意：此函数实际上并没有直接返回拼接的字符串，而是返回了值的数组  
    // 如果需要返回字符串，可以在调用该函数后处理数组  
    return result;
}

function replaceValues(obj, replacementMap) {  
    // 检查当前obj是否是对象或数组  
    if (typeof obj === 'object' && obj !== null) {  
        Object.keys(obj).forEach(key => {  
            // 递归处理子对象或数组  
            if (typeof obj[key] === 'object' && obj[key] !== null) {  
                replaceValues(obj[key], replacementMap);  
            } else {  
                // 如果当前值在replacementMap中存在，则替换它  
                if (replacementMap.hasOwnProperty(obj[key])) {  
                    obj[key] = replacementMap[obj[key]];  
                }
                // 注意：这里没有处理数组中的非对象元素，因为它们通常不会被替换为其他类型的值  
            }  
        });  
    }  

    return obj;
    // 注意：这个函数不会修改非对象或数组的值  
    // 如果需要处理更复杂的情况（比如数组中的非对象元素），则需要额外的逻辑  
}  
main()